{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run a simulation with `BrainPy`, users will mainly use three classes: two fundamental classes `brainpy.NeuGroup` and `brainpy.SynConn`, which refers to groups of neurons and synapses, respectively; and class `brainpy.Network`, with which users can build a neural network and simulate the whole network as an ensemble. \n",
    "\n",
    "In [build neurons](https://brainpy.readthedocs.io/en/latest/tutorials/build_neurons.html) and [build synapses](https://brainpy.readthedocs.io/en/latest/tutorials/build_synapses.html), we have already introduced how to define `brainpy.NeuType` and `brainpy.SynType`. Base on former introductions, in this section, we will first introduce `brainpy.NeuGroup` and `brainpy.SynConn`, then transition to the contruction and simulation of neural networks with `brainpy.Network`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import brainpy as bp\n",
    "import bpmodels\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.NeuGroup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Users can implement a group of neurons as an object of `NeuGroup` class. Five input parameters are provided to the class contructor to describe the neuron group:\n",
    "\n",
    "- `model`: The neuron models used to generate the neuron group.\n",
    "- `geometry`: Geometry of the neuron group. Can be a int or a two-tuple of int.\n",
    "- `pars_update`: Parameters to update. (??? is this clear?)\n",
    "- `monitors`: List of ST members to monitor. \n",
    "- `name`: Name of neuron group. Will be automatically assigned if not given.\n",
    "\n",
    "Example code:\n",
    "\n",
    "    neu_group_1 = bp.NeuGroup(model=LIF, geometry=(10, ), monitors=['V'])\n",
    "\n",
    "Parameter `geometry` represents the geometry of the neuron group users build. As `BrainPy` supports one-dimensional and two-dimensional neuron structure, `geometry` should be a int or a (int, int) tuple.\n",
    "\n",
    "Parameter `monitors` includes the ST members that will be recorded during simulation. If a ST member is listed in `monitors`, its time series will be saved in variable `<NEU_GROUP_NAME>.mon.<MEM_NAME>` for later use.\n",
    "\n",
    "Example code:\n",
    "\n",
    "    V_time_series = neu.mon.V[START_TIME:END_TIME, NEURON_NO]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`NeuGroup` supports index and slice operation, both for one-dimensional and two-dimensional geometry. Users can include all the neurons of the same model in one neuron group, then operate different subgroups of it.\n",
    "\n",
    "Example code:\n",
    "    \n",
    "    neu_group_2 = bp.NeuGroup(model = LIF, geometry = (100, 100))\n",
    "    sub_group_1 = neu_group_2[:50]\n",
    "    sub_group_2 = neu_group_2[:5, :5]\n",
    "    syn_conn_1 = bp.SynConn(model = AMPA, \n",
    "                            pre_group = sub_group_2, \n",
    "                            post_group = neu_group_2[:10, :10],\n",
    "                            conn = bp.connect.All2All())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Users can schedule the order to run subfunctions in the neuron groups with member function `runner.set_schedule`. The input parameter of function `set_schedule` is a list of the functions users and `BrainPy` utilized in the model.\n",
    "\n",
    "Example code:\n",
    "\n",
    "    neu.runner.set_schedule(['input', 'update', 'monitor', 'reset'])\n",
    "\n",
    "Users can set parameters and initialize ST members after building neuron group. BrainPy also support heterogeneous parameter assignment: users can assign different values to the same ST member or parameter of different neurons in a neuron group.\n",
    "\n",
    "Example code:\n",
    "    \n",
    "    neu_group_1.pars['V_rest'] = np.random.randint(0, 2, size=(10,))\n",
    "    \n",
    "    neu_group_1.ST['V'] = -65."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.SynConn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Users implement a group of synapses as an object of `SynConn` class. Nine input parameters are provided to the class contructor to describe the synapse connections:\n",
    "\n",
    "- `model`: The neuron models used to generate the neuron group.\n",
    "- `pars_update`: Parameters to update. (??? is this clear?)\n",
    "- `pre_group`: Pre-synaptic neuron group.\n",
    "- `post_group`: Post-synaptic neuron group.\n",
    "- `conn`: Connection method to create synaptic connectivity.\n",
    "- `num`: Number of synapses.\n",
    "- `delay`: Time of synaptic delay.\n",
    "- `monitors`: List of ST members to monitor. \n",
    "- `name`: Name of neuron group. Will be automatically assigned if not given."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`BrainPy` implements two ways to define a set of synapse connection:\n",
    "\n",
    "-- 1. Assign values to the parameters `pre_group`, `post_group` and `conn`, and leave the parameter `num` blank. In this case, `pre_group` and `post_group` are two objects of `NeuGroup` class, and parameter `conn` specifies the connection strategy `BrainPy` will use to build synapses.\n",
    "\n",
    "Eample code:\n",
    "\n",
    "    gabaa = bp.SynConn(model=GABAa_syn, pre_group=pre, post_group=post, \n",
    "                       conn=bp.connect.All2All(), monitors=['s'], delay=10.)\n",
    "\n",
    "-- 2. Assign value to the parameter `num`, leave the parameters `pre_group`, `post_group` and `conn` blank. After `SynConn` object has been defined, users should assign value to four members of `SynConn`: `pre`, `post`, `pre2syn` and `post2syn`. In this case, `num` refers to the number of synapses, `pre` and `post` choose which neurons are to be connected, `pre2syn` and `post2syn` map the synapse and the pre-synaptic, post-synaptic neurons.\n",
    "\n",
    "Example code:\n",
    "\n",
    "    syn = bp.SynConn(model = syn_model, num = delta_t_num, \n",
    "                      monitors = ['w'], delay = 10.)\n",
    "    syn.pre = bp.types.NeuState(['spike'])(2)\n",
    "    syn.post = bp.types.NeuState(['V', 'input', 'spike'])(2)\n",
    "    pre2syn_list = [[1, 1], [2, 2]]\n",
    "    post2syn_list = [[1, 1], [2, 2]]\n",
    "    syn.pre2syn = syn.requires['pre2syn'].make_copy(pre2syn_list)\n",
    "    syn.post2syn = syn.requires['post2syn'].make_copy(post2syn_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameter `delay` refers to the synapse delay time. According to the biological nature of synapses, there is a time delay between the moment pre-synaptic spike affects the synapse state and the moment synapse state affects the post-synaptic spike. `BrainPy` realizes this delay with decorator `@brainpy.delayed`, and it will be automatically computed with proper defination of `NeuType` (See [build synapses](https://brainpy.readthedocs.io/en/latest/tutorials/build_synapses.html) for detail).\n",
    "\n",
    "Parameter `monitors` includes the ST members that will be recorded during simulation. If a ST member is listed in `monitors`, its time series will be saved in variable `<NEU_GROUP_NAME>.mon.<MEM_NAME>` for later use.\n",
    "\n",
    "Example code:\n",
    "\n",
    "    w_time_series = syn.mon.w[START_TIME:END_TIME, NEURON_NO]\n",
    "\n",
    "Users can schedule the order to run subfunctions in the synapse connections with member function `runner.set_schedule`. The input parameter of function `set_schedule` is a list of the functions users and `BrainPy` utilized in the model.\n",
    "\n",
    "Example code:\n",
    "\n",
    "    syn.runner.set_schedule(['input', 'update', 'output', 'monitor'])\n",
    "\n",
    "Users can set parameters and initialize ST members after building synapse connections. BrainPy also support heterogeneous parameter assignment: users can assign different values to the same ST member or parameter of different synapses in a synapse connection.\n",
    "\n",
    "Example code:\n",
    "    \n",
    "    syn_conn_1.pars['w'] = np.random.rand(syn_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To initialize a neural network, i.e. an object of `brainpy.Network` class, a list of `NeuGroup` and `SynConn` objects should be provided to the `Network` constructor as input parameters. These objects will compose the network.\n",
    "\n",
    "- `*args`: List of objects.\n",
    "- `mode`: If the model will be simulated repeatly.\n",
    "- `**kwargs`: List of object names. If this parameter is not provided, the object will be automatically named.\n",
    "\n",
    "These objects can be accessed via their names, e.g. `NET_NAME.OBJ_NAME`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example code:\n",
    "\n",
    "    net = bp.Network(neu_group_1, neu_group_2, syn_conn_1, syn_conn_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### add"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Users can add objects to the network using member function `add` of class `Network` after initialization is done. Input parameters of function `add` is similar to the ones of constructors function.\n",
    "\n",
    "- `*args`: List of objects.\n",
    "- `**kwargs`: List of object names. If this parameter is not provided, the object will be automatically named."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`BrainPy` run simulation with member function `run` of class `Network`.\n",
    "\n",
    "- `duration` : The amount of simulation time (ms) to run for.\n",
    "- `inputs` : List of external inputs, each element is a quadruple of (receiver, item, external input, [operation]), operation is set to '+' by default if not given. Default = ().\n",
    "- `report` : Report the progress of the simulation. Default = false.\n",
    "- `report_percent` : The interval of simulation progress reporting. Default = 0.1.\n",
    "\n",
    "The items of `inputs` quadruple:\n",
    "\n",
    "- `receiver`: The `NeuGroup` or `SynConn` object that receives the input.\n",
    "- `item`: Specific item of the receiver that receives the input.\n",
    "- `external input`: Description of the input time series.\n",
    "- `operation`: Which operation should the item take when it receives the input.\n",
    "\n",
    "`BrainPy` supports diverse input methods. The `operation` item can be set as one of { + , - , * , / , = }, and if users do not provide this item explictly, it will be set to '+' by default. The value of `operation` defines in which way the input will be given to the receive item. Generally, users can see it as a binary operator. For example, if `operation == '+'`, then in a single update, the value of receive item `val = val + input`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example code:\n",
    "\n",
    "    net.run(duration=100., inputs=[(neu_group_1, 'ST.input', 1.)], report=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After calling `run` function, `NeuGroup` and `SynConn` objects in the network will be updated in the way they were defined in their description, and in the order they were provided to the `Network` constructor as input parameters. We should mention that this order barely affects the simulation result, because the update interval `dt` are relatively small, therefore single update will not cause a sharp change in variable values.\n",
    "\n",
    "Note:\n",
    "\n",
    "> i. Users can directly run `NeuGroup` with member function `NeuGroup.run`. However, `SynConn` can not be run in this way. See more details in [build neurons](https://brainpy.readthedocs.io/en/latest/tutorials/build_neurons.html) and [build synapses](https://brainpy.readthedocs.io/en/latest/tutorials/build_synapses.html).\n",
    "\n",
    "> ii. Although the calculation order barely affects the simulation progress, users should be aware of the order and deal with relative assignments carefully, otherwise this feature may cause a bug."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## E/I balance network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We take E/I balance network as an example. E/I balance network is a canonical network model, in which the populations of excitatory and inhibitory neurons achieve an approximate balance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set global parameters\n",
    "bp.profile.set(jit=True, device='cpu',\n",
    "               numerical_method='exponential')\n",
    "\n",
    "num_exc = 500\n",
    "num_inh = 500\n",
    "prob = 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neuron model is defined as:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\tau \\frac{d V}{d t} = -(V - V_{rest} + I^{ext} + I^{net}(t))$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With a threshold of `-50mV` and a refractory of `5ms` ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define neuron model as bp.NeuType\n",
    "V_rest = -52.\n",
    "V_reset = -60.\n",
    "V_th = -50.\n",
    "R=1.\n",
    "tau=10.\n",
    "t_refractory=5.\n",
    "noise=0.\n",
    "\n",
    "ST_neu = bp.types.NeuState(\n",
    "             {'V': 0, 'input': 0, 'spike': 0, 'refractory': 0, 't_last_spike': -1e7}\n",
    "         )\n",
    "\n",
    "@bp.integrate\n",
    "def int_V(V, _t, I_ext):  # integrate u(t)\n",
    "    return (- (V - V_rest) + R * I_ext) / tau, noise / tau\n",
    "\n",
    "def update(ST, _t):\n",
    "    # update variables\n",
    "    ST['spike'] = 0\n",
    "    if _t - ST['t_last_spike'] <= t_refractory:\n",
    "        ST['refractory'] = 1.\n",
    "    else:\n",
    "        ST['refractory'] = 0.\n",
    "        V = int_V(ST['V'], _t, ST['input'])\n",
    "        if V >= V_th:\n",
    "            V = V_reset\n",
    "            ST['spike'] = 1\n",
    "            ST['t_last_spike'] = _t\n",
    "        ST['V'] = V\n",
    "    \n",
    "def reset(ST):\n",
    "    ST['input'] = 0.\n",
    "\n",
    "\n",
    "neu = bp.NeuType(name='LIF',\n",
    "                 ST=ST_neu,\n",
    "                 steps=(update, reset),\n",
    "                 mode='scalar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Synapse model is defined as:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "\\label{eq6}\n",
    "f(t) =\\left\\{\n",
    "\\begin{aligned}\n",
    "exp(-\\frac{t}{\\tau_s}) & , & t \\geq 0 , \\\\\n",
    "0 & , & t < 0.\n",
    "\\end{aligned}\n",
    "\\right.\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ I^{net}(t) = J_E \\sum_{j=1}^{p N_E}\\sum_{t_j^\\alpha < t}f(t - t_j^\\alpha) - J_I \\sum_{j=1}^{pN_I}\\sum_{t_j^\\alpha < t}f(t - t_j^\\alpha)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define synapse model as bp.SynType\n",
    "tau_decay = 2.\n",
    "JE = 1 / np.sqrt(prob * num_exc)\n",
    "JI = 1 / np.sqrt(prob * num_inh)\n",
    "\n",
    "ST_syn = bp.types.SynState({'s':0., 'w': .1, 'g':0.}, help='synapse state.')\n",
    "\n",
    "@bp.integrate\n",
    "def ints(s, t):\n",
    "    return - s / tau_decay\n",
    "\n",
    "\n",
    "def update(ST, _t, pre):\n",
    "    s = ints(ST['s'], _t)\n",
    "    s += pre['spike']\n",
    "    ST['s'] = s\n",
    "    ST['g'] = ST['w'] * s\n",
    "\n",
    "\n",
    "def output(ST, post):\n",
    "    post['input'] += ST['g']\n",
    "\n",
    "\n",
    "syn = bp.SynType(name='alpha_synapse',\n",
    "                 ST=ST_syn,\n",
    "                 steps=(update, output),\n",
    "                 mode='scalar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After neuron model and synapse model are built, we generate the concrete neuron group and synapse connections. Note that we assign heterogeneous initial values to ST members, and build synapse connections between two subgroups of one neuron group using the slice operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate bp.NeuGroup & bp.SynConn\n",
    "group = bp.NeuGroup(neu, geometry=num_exc + num_inh, monitors=['spike'])\n",
    "\n",
    "group.ST['V'] = np.random.random(num_exc + num_inh) * (V_th - V_rest) + V_rest\n",
    "\n",
    "exc_conn = bp.SynConn(syn,\n",
    "                      pre_group=group[:num_exc],\n",
    "                      post_group=group,\n",
    "                      conn=bp.connect.FixedProb(prob=prob))\n",
    "exc_conn.ST['w'] = JE\n",
    "\n",
    "inh_conn = bp.SynConn(syn,\n",
    "                      pre_group=group[num_exc:],\n",
    "                      post_group=group,\n",
    "                      conn=bp.connect.FixedProb(prob=prob))\n",
    "exc_conn.ST['w'] = -JI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To integrate the neuron groups and synapse connection into a network, we initialize an object of `brainpy.Network` class with these previous defined objects, then run the network with member function `run`. In this progress, we simulate the network for 500 ms, give a constant input of amplitude `3.` to all the neurons in neuron group, and report the simulation progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 0.5022 s.\n",
      "Start running ...\n",
      "Run 10.0% used 0.088 s.\n",
      "Run 20.0% used 0.174 s.\n",
      "Run 30.0% used 0.275 s.\n",
      "Run 40.0% used 0.393 s.\n",
      "Run 50.0% used 0.483 s.\n",
      "Run 60.0% used 0.577 s.\n",
      "Run 70.0% used 0.665 s.\n",
      "Run 80.0% used 0.770 s.\n",
      "Run 90.0% used 0.857 s.\n",
      "Run 100.0% used 0.942 s.\n",
      "Simulation is done in 0.942 s.\n"
     ]
    }
   ],
   "source": [
    "net = bp.Network(group, exc_conn, inh_conn)\n",
    "net.run(duration=500., inputs=(group, 'ST.input', 3.), report=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After visualization, users can see the typical oscillation pattern of E/I balance network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, gs = bp.visualize.get_figure(4, 1, 2, 10)\n",
    "\n",
    "fig.add_subplot(gs[:3, 0])\n",
    "bp.visualize.raster_plot(net.ts, group.mon.spike, xlim=(50, 450))\n",
    "\n",
    "fig.add_subplot(gs[3, 0])\n",
    "rates = bp.measure.firing_rate(group.mon.spike, 5.)\n",
    "plt.plot(net.ts, rates)\n",
    "plt.xlim(50, 450)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
